home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 26 / Cream of the Crop 26.iso / program / ddj0897.zip / DYN401.ZIP / class / set.c < prev    next >
C/C++ Source or Header  |  1997-04-16  |  13KB  |  620 lines
  1.  
  2.  
  3. /*  Copyright (c) 1993-1996 Algorithms Corporation  */
  4. /*  All rights reserved.  */
  5.  
  6.  
  7.  
  8.  
  9. /*  This file automatically generated by dpp - do not edit  */
  10.  
  11. #define    DPP_STRATEGY    2
  12. #define    DPP_FASTWIDE    0
  13.  
  14.  
  15.  
  16. #line 16 "set.d"
  17. #include <string.h> 
  18. #include <math.h> 
  19.  
  20. #include "set1.h" 
  21.  
  22. #define    CLASS    Set_c
  23. #define    ivType    Set_iv_t
  24.  
  25. #include "generics.h"
  26.  
  27. object    Set_c;
  28.  
  29.  
  30. #line 31 "set.c"
  31. typedef struct  _Set_iv_t  {
  32.     int iSize;
  33.     int iNelm;
  34.     NODE * iTab;
  35.     CRITICALSECTION iCS;
  36. }    Set_iv_t;
  37.  
  38.  
  39. #line 40 "set.c"
  40. typedef struct  _Set_cv_t  {
  41.     NODE FNODES;
  42.     CRITICALSECTION cCS;
  43. }    Set_cv_t;
  44.  
  45. static    Set_cv_t    *Set_cv;
  46.  
  47.  
  48. #line 35 "set.d"
  49. static objrtn Lookup(object self, object luk, int mode, int deep, int type, object value); 
  50.  
  51. #define LTYPE 0 
  52.  
  53. #define NODE_BLOCK_SIZE 50 
  54.  
  55. static NODE new_node(void) 
  56. { 
  57.     int i; 
  58.     volatile NODE r; 
  59.  
  60.     ENTERCRITICALSECTION(Set_cv->cCS); 
  61.     if (!Set_cv->FNODES) { 
  62.         Set_cv->FNODES = Tncalloc(struct NODES, NODE_BLOCK_SIZE); 
  63.         for (i=0 ; i != (NODE_BLOCK_SIZE-1) ; ++i) 
  64.             Set_cv->FNODES[i].next = Set_cv->FNODES + (i + 1); 
  65.         gRegisterMemory(Dynace, Set_cv->FNODES, (long)(sizeof(struct NODES) * NODE_BLOCK_SIZE)); 
  66.     } 
  67.     r = Set_cv->FNODES; 
  68.     Set_cv->FNODES = Set_cv->FNODES->next; 
  69.     LEAVECRITICALSECTION(Set_cv->cCS); 
  70.     return r; 
  71. } 
  72.  
  73. static void free_node(NODE i) 
  74. { 
  75.     ENTERCRITICALSECTION(Set_cv->cCS); 
  76.     i->luk = NULL; 
  77.     i->next = Set_cv->FNODES; 
  78.     Set_cv->FNODES = i; 
  79.     LEAVECRITICALSECTION(Set_cv->cCS); 
  80. } 
  81.  
  82. cmeth objrtn New(object self, int size)
  83. { 
  84.     object set = oSuper(Set_c, gNew, self)(self); 
  85.     ivType *iv = ivPtr(set); 
  86.     iv->iSize = size; 
  87.     iv->iTab = Tncalloc(NODE, size); 
  88.     INITIALIZECRITICALSECTION(iv->iCS); 
  89.     return set; 
  90. } 
  91.  
  92. cmeth objrtn Set_cm_gNew(object self)
  93. { 
  94.     return New(self, 51); 
  95. } 
  96.  
  97. static objrtn _copy(object self, int deep)
  98. { Set_iv_t *iv = GetIVs(Set, self);
  99.     object nobj; 
  100.     ivType *iv2; 
  101.     int i; 
  102.  
  103.     ENTERCRITICALSECTION(iv->iCS); 
  104.     if (deep < 2) 
  105.         nobj = oSuper(Set_c, gCopy, self)(self); 
  106.     else 
  107.         nobj = oSuper(Set_c, gDeepCopy, self)(self); 
  108.     iv2 = ivPtr(nobj); 
  109.  
  110.     iv2->iSize = iv->iSize; 
  111.     iv2->iTab = Tncalloc(NODE, iv2->iSize); 
  112.     for (i=0 ; i != iv2->iSize ; ++i) { 
  113.         NODE n, n2, p; 
  114.  
  115.         for (n=iv->iTab[i], p=NULL ; n ; p=n2, n=n->next) { 
  116.             n2 = new_node(); 
  117.             switch (deep) { 
  118.                 case 0: 
  119.                 default: 
  120.                 n2->luk = n->luk; 
  121.                 break; 
  122.                 case 1: 
  123.                 n2->luk = gCopy(n->luk); 
  124.                 break; 
  125.                 case 2: 
  126.                 n2->luk = gDeepCopy(n->luk); 
  127.                 break; 
  128.             } 
  129.             n2->next = NULL; 
  130.             if (p) 
  131.                 p->next = n2; 
  132.             else 
  133.                 iv2->iTab[i] = n2; 
  134.         } 
  135.     } 
  136.     LEAVECRITICALSECTION(iv->iCS); 
  137.     return nobj; 
  138. } 
  139.  
  140. imeth objrtn Set_im_gCopy(object self)
  141. { 
  142.     return _copy(self, ClassOf(self) != CLASS); 
  143. } 
  144.  
  145. imeth objrtn Set_im_gDeepCopy(object self)
  146. { 
  147.     return _copy(self, 2); 
  148. } 
  149.  
  150.  
  151.  
  152.  
  153.  
  154. imeth int Set_im_gSize(object self)
  155. { Set_iv_t *iv = GetIVs(Set, self);
  156.     return iv->iNelm; 
  157. } 
  158.  
  159. static objrtn _delete(object self, int mode, int entire)
  160. { Set_iv_t *iv = GetIVs(Set, self);
  161.     int i; 
  162.  
  163.     ENTERCRITICALSECTION(iv->iCS); 
  164.     for (i=0 ; i != iv->iSize ; ++i) { 
  165.         NODE n, p = iv->iTab[i]; 
  166.  
  167.         for (; p ; p = n) { 
  168.             if (mode == 1) 
  169.                 gDispose(p->luk); 
  170.             else if (mode == 2) 
  171.                 gDeepDispose(p->luk); 
  172.             n = p->next; 
  173.             free_node(p); 
  174.         } 
  175.         iv->iTab[i] = NULL; 
  176.     } 
  177.     if (entire) { 
  178.         free(iv->iTab); 
  179.         LEAVECRITICALSECTION(iv->iCS); 
  180.         DELETECRITICALSECTION(iv->iCS); 
  181.         self = oSuper(Set_c, gDispose, self)(self); 
  182.     } else { 
  183.         iv->iNelm = 0; 
  184.         LEAVECRITICALSECTION(iv->iCS); 
  185.     } 
  186.     return self; 
  187. } 
  188.  
  189. imeth objrtn Set_im_gDispose(object self)
  190. { 
  191.     return _delete(self, 0, 1); 
  192. } 
  193.  
  194. imeth objrtn Set_im_gDeepDispose(object self)
  195. { 
  196.     return _delete(self, 2, 1); 
  197. } 
  198.  
  199. imeth objrtn Set_im_gDispose1(object self)
  200. { 
  201.     return _delete(self, 1, 1); 
  202. } 
  203.  
  204. imeth objrtn Set_im_gDisposeAllNodes(object self)
  205. { 
  206.     return _delete(self, 0, 0); 
  207. } 
  208.  
  209. imeth objrtn Set_im_gDeepDisposeAllNodes(object self)
  210. { 
  211.     return _delete(self, 2, 0); 
  212. } 
  213.  
  214. imeth objrtn Set_im_gDisposeAllNodes1(object self)
  215. { 
  216.     return _delete(self, 1, 0); 
  217. } 
  218.  
  219.  
  220.  
  221. imeth objrtn Set_im_gForAll(object self, object (*fun)())
  222. { Set_iv_t *iv = GetIVs(Set, self);
  223.     int i; 
  224.  
  225.     ENTERCRITICALSECTION(iv->iCS); 
  226.     for (i=0 ; i != iv->iSize ; ++i) { 
  227.         NODE p = iv->iTab[i]; 
  228.         object v; 
  229.  
  230.         for (; p ; p = p->next) 
  231.             if (v = (*(object (*)(object))fun)(p->luk)) { 
  232.             LEAVECRITICALSECTION(iv->iCS); 
  233.             return(v); 
  234.         } 
  235.     } 
  236.     LEAVECRITICALSECTION(iv->iCS); 
  237.     return NULL; 
  238. } 
  239.  
  240. imeth objrtn Set_im_gStringRep(object self)
  241. { Set_iv_t *iv = GetIVs(Set, self);
  242.     int i; 
  243.     object s, t; 
  244.  
  245.     s = oSuper(Set_c, gStringRepValue, self)(self); 
  246.     gAppend(s, (object) "  [\n"); 
  247.     for (i=0 ; i != iv->iSize && !iv->iTab[i] ; ++i); 
  248.     while (i != iv->iSize) { 
  249.         NODE p = iv->iTab[i]; 
  250.  
  251.         while (++i != iv->iSize && !iv->iTab[i]); 
  252.         while (p) { 
  253.             t = gStringRepValue(p->luk); 
  254.             if ((p = p->next) || i != iv->iSize) 
  255.                 vBuild(s, NULL, "\t", t, ",\n", NULL); 
  256.             else 
  257.                 vBuild(s, NULL, "\t", t, "\n", NULL); 
  258.             gDispose(t); 
  259.         } 
  260.     } 
  261.     gAppend(s, (object) "]\n"); 
  262.     return s; 
  263. } 
  264.  
  265.  
  266.  
  267.  
  268.  
  269. imeth objrtn Set_im_gAdd(object self, object luk)
  270. { 
  271.     ChkArg(luk, 2); 
  272.     return Lookup(self, luk, HT_ADD, 0, LTYPE, NULL); 
  273. } 
  274.  
  275.  
  276.  
  277. imeth objrtn Set_im_gFind(object self, object luk)
  278. { 
  279.     ChkArg(luk, 2); 
  280.     return Lookup(self, luk, HT_FIND, 0, LTYPE, NULL); 
  281. } 
  282.  
  283.  
  284.  
  285. imeth objrtn Set_im_gFindAdd(object self, object luk)
  286. { 
  287.     ChkArg(luk, 2); 
  288.     return Lookup(self, luk, HT_FINDADD, 0, LTYPE, NULL); 
  289. } 
  290.  
  291.  
  292.  
  293. imeth objrtn Set_im_gRemoveObj(object self, object luk)
  294. { 
  295.     ChkArg(luk, 2); 
  296.     return Lookup(self, luk, HT_DELETE, 0, LTYPE, NULL); 
  297. } 
  298.  
  299.  
  300.  
  301. imeth objrtn Set_im_gDisposeObj(object self, object luk)
  302. { 
  303.     ChkArg(luk, 2); 
  304.     return Lookup(self, luk, HT_DELETE, 1, LTYPE, NULL); 
  305. } 
  306.  
  307.  
  308.  
  309. imeth objrtn Set_im_gDeepDisposeObj(object self, object luk)
  310. { 
  311.     ChkArg(luk, 2); 
  312.     return Lookup(self, luk, HT_DELETE, 2, LTYPE, NULL); 
  313. } 
  314.  
  315.  
  316.  
  317. static objrtn _deleteGroup(object self, int (*fun)(), int deep)
  318. { Set_iv_t *iv = GetIVs(Set, self);
  319.     int i; 
  320.     NODE n, lastp, p; 
  321.  
  322.     ENTERCRITICALSECTION(iv->iCS); 
  323.     for (i=0 ; i != iv->iSize ; ++i) { 
  324.         for (lastp=NULL, p=iv->iTab[i] ; p ; ) 
  325.             if ((*(int (*)(object))fun)(p->luk)) { 
  326.             if (deep == 1) 
  327.                 gDispose(p->luk); 
  328.             else if (deep == 2) 
  329.                 gDeepDispose(p->luk); 
  330.             if (lastp) 
  331.                 lastp->next = n = p->next; 
  332.             else 
  333.                 iv->iTab[i] = n = p->next; 
  334.             free_node(p); 
  335.             p = n; 
  336.             --iv->iNelm; 
  337.         } else { 
  338.             lastp = p; 
  339.             p = p->next; 
  340.         } 
  341.     } 
  342.     LEAVECRITICALSECTION(iv->iCS); 
  343.     return self; 
  344. } 
  345.  
  346. imeth objrtn Set_im_gGroupRemove(object self, int (*fun)())
  347. { 
  348.     return _deleteGroup(self, fun, 0); 
  349. } 
  350.  
  351. imeth objrtn Set_im_gDisposeGroup(object self, int (*fun)())
  352. { 
  353.     return _deleteGroup(self, fun, 1); 
  354. } 
  355.  
  356. imeth objrtn Set_im_gDeepDisposeGroup(object self, int (*fun)())
  357. { 
  358.     return _deleteGroup(self, fun, 2); 
  359. } 
  360.  
  361.  
  362.  
  363.  
  364. imeth objrtn Set_im_gResize(object self, int size)
  365. { Set_iv_t *iv = GetIVs(Set, self);
  366.     NODE *v; 
  367.     int i, sz; 
  368.  
  369.     ENTERCRITICALSECTION(iv->iCS); 
  370.     v = iv->iTab; 
  371.     sz = iv->iSize; 
  372.     iv->iSize = size; 
  373.     iv->iTab = Tncalloc(NODE, size); 
  374.     iv->iNelm = 0; 
  375.     for (i=0 ; i != sz ; ++i) { 
  376.         NODE n, t; 
  377.  
  378.         for (n=v[i] ; n ; n = t) { 
  379.             Lookup(self, n->luk, HT_ADD, 0, LTYPE, NULL); 
  380.             t = n->next; 
  381.             free_node(n); 
  382.         } 
  383.     } 
  384.     free(v); 
  385.     LEAVECRITICALSECTION(iv->iCS); 
  386.     return self; 
  387. } 
  388.  
  389. static unsigned hash_string(char *s) 
  390. { 
  391.     register char c = 'a'; 
  392.     double t; 
  393.     register unsigned short k=0; 
  394.  
  395.     while (*s) 
  396.         k += *s++ ^ c++; 
  397.     t = .6125423371 * k; 
  398.     t = t < 0.0 ? -t : t; 
  399.     return (int) (BIG_INT * (t - floor(t))); 
  400. } 
  401.  
  402. static unsigned hash_short(int val) 
  403. { 
  404.     double t; 
  405.  
  406.     t = .6125423371 * (unsigned) val; 
  407.     t = t < 0.0 ? -t : t; 
  408.     return (unsigned) (BIG_INT * (t - floor(t))); 
  409. } 
  410.  
  411. imeth objrtn Lookup(object self, object luk, int mode, int deep, int type, object value)
  412.  
  413.  
  414.  
  415. { Set_iv_t *iv = GetIVs(Set, self);
  416.     NODE e, laste=NULL, newe; 
  417.     unsigned idx; 
  418.     int i=0; 
  419.     struct _Object_iv_t * volatile ret; 
  420.  
  421.     ENTERCRITICALSECTION(iv->iCS); 
  422.     if (type == 2) 
  423.         idx = hash_string((char *) luk) % iv->iSize; 
  424.     else if (type == 3 || type == 4) 
  425.         idx = hash_short(*((int *) luk)) % iv->iSize; 
  426.     else 
  427.         idx = gHash(luk) % iv->iSize; 
  428.     if (idx >= (unsigned) iv->iSize) 
  429.         idx %= iv->iSize; 
  430.     e = iv->iTab[idx]; 
  431.     while (1) { 
  432.         if (e == NULL) { 
  433.             if (mode != HT_ADD && mode != HT_FINDADD) { 
  434.                 LEAVECRITICALSECTION(iv->iCS); 
  435.                 return(NULL); 
  436.             } 
  437.             e = new_node(); 
  438.             switch (type) { 
  439.                 case 0: 
  440.                 default: 
  441.                 e->luk = luk; 
  442.                 break; 
  443.                 case 1: 
  444.                 e->luk = gNewWithObjObj(ObjectAssociation, luk, value); 
  445.                 break; 
  446.                 case 2: 
  447.                 e->luk = gNewWithStrObj(StringAssociation, (char *) luk, value); 
  448.                 break; 
  449.  
  450.  
  451.  
  452.                 case 4: 
  453.                 e->luk = gNewWithIntObj(IntegerAssociation, *((int *)luk), value); 
  454.                 break; 
  455.             } 
  456.             e->next = NULL; 
  457.             if (laste) 
  458.                 laste->next = e; 
  459.             else 
  460.                 iv->iTab[idx] = e; 
  461.             ++iv->iNelm; 
  462.             break; 
  463.         } 
  464.         switch (type) { 
  465.             case 0: 
  466.             i = e->luk == luk ? 0 : gCompare(e->luk, luk); 
  467.             break; 
  468.             case 1: { 
  469.                 object t = gKey(e->luk); 
  470.                 i = t == luk ? 0 : gCompare(t, luk); 
  471.                 break; 
  472.             } 
  473.             case 2: { 
  474.                 char *t = gStringKey(e->luk); 
  475.                 i = t == (char *) luk ? 0 : strcmp(t, (char *) luk); 
  476.                 break; 
  477.             } 
  478.  
  479.  
  480.  
  481.             case 4: 
  482.             i = gIntKey(e->luk) - *((int *) luk); 
  483.             break; 
  484.         } 
  485.         if (!i) { 
  486.             if (mode == HT_ADD) { 
  487.                 LEAVECRITICALSECTION(iv->iCS); 
  488.                 return(NULL); 
  489.             } 
  490.             if (mode == HT_DELETE) { 
  491.                 if (deep == 1) 
  492.                     gDispose(e->luk); 
  493.                 else if (deep == 2) 
  494.                     gDeepDispose(e->luk); 
  495.                 if (laste) 
  496.                     laste->next = e->next; 
  497.                 else 
  498.                     iv->iTab[idx] = e->next; 
  499.                 ret = e->luk; 
  500.                 free_node(e); 
  501.                 --iv->iNelm; 
  502.                 LEAVECRITICALSECTION(iv->iCS); 
  503.                 return deep ? self : (object) ret; 
  504.             } 
  505.             break; 
  506.         } else if (i > 0) { 
  507.             if (mode != HT_ADD && mode != HT_FINDADD) { 
  508.                 LEAVECRITICALSECTION(iv->iCS); 
  509.                 return(NULL); 
  510.             } 
  511.             newe = new_node(); 
  512.             switch (type) { 
  513.                 case 0: 
  514.                 default: 
  515.                 newe->luk = luk; 
  516.                 break; 
  517.                 case 1: 
  518.                 newe->luk = gNewWithObjObj(ObjectAssociation, luk, value); 
  519.                 break; 
  520.                 case 2: 
  521.                 newe->luk = gNewWithStrObj(StringAssociation, (char *) luk, value); 
  522.                 break; 
  523.  
  524.  
  525.  
  526.                 case 4: 
  527.                 newe->luk = gNewWithIntObj(IntegerAssociation, *((int *) luk), value); 
  528.                 break; 
  529.             } 
  530.             newe->next = e; 
  531.             if (laste) 
  532.                 laste->next = newe; 
  533.             else 
  534.                 iv->iTab[idx] = newe; 
  535.             e = newe; 
  536.             ++iv->iNelm; 
  537.             break; 
  538.         } else { 
  539.             laste = e; 
  540.             e = e->next; 
  541.         } 
  542.     } 
  543.     ret = e->luk; 
  544.     LEAVECRITICALSECTION(iv->iCS); 
  545.     return (object) ret; 
  546. } 
  547.  
  548. imeth objrtn Set_im_gSequence(object self)
  549. { Set_iv_t *iv = GetIVs(Set, self);
  550.     return gNewSetSeq(SetSequence, iv->iSize, iv->iNelm, (void *) iv->iTab); 
  551. } 
  552.  
  553. static void class_init(void) 
  554. { 
  555.     INITIALIZECRITICALSECTION(Set_cv->cCS); 
  556. } 
  557.  
  558. #line 559 "set.c"
  559.  
  560. objrtn    Set_initialize(void)
  561. {
  562.     static  CRITICALSECTION  cs;
  563.     static  int volatile once = 0;
  564.  
  565.     ENTERCRITICALSECTION(_CI_CS_);
  566.     if (!once) {
  567.         INITIALIZECRITICALSECTION(cs);
  568.         once = 1;
  569.     }
  570.     LEAVECRITICALSECTION(_CI_CS_);
  571.  
  572.     ENTERCRITICALSECTION(cs);
  573.  
  574.     if (Set_c) {
  575.         LEAVECRITICALSECTION(cs);
  576.         return Set_c;
  577.     }
  578.     INHIBIT_THREADER;
  579.     Set_c = gNewClass(Class, "Set", sizeof(Set_iv_t), sizeof(Set_cv_t), END);
  580.     cMethodFor(Set, gNewWithInt, New);
  581.     cMethodFor(Set, gNew, Set_cm_gNew);
  582.     iMethodFor(Set, gDeepDisposeObj, Set_im_gDeepDisposeObj);
  583.     iMethodFor(Set, gFindAdd, Set_im_gFindAdd);
  584.     iMethodFor(Set, gDispose1, Set_im_gDispose1);
  585.     iMethodFor(Set, gDeepDisposeGroup, Set_im_gDeepDisposeGroup);
  586.     iMethodFor(Set, gFind, Set_im_gFind);
  587.     iMethodFor(Set, gDisposeObj, Set_im_gDisposeObj);
  588.     iMethodFor(Set, gDisposeAllNodes, Set_im_gDisposeAllNodes);
  589.     iMethodFor(Set, gSize, Set_im_gSize);
  590.     iMethodFor(Set, gDeepDisposeAllNodes, Set_im_gDeepDisposeAllNodes);
  591.     iMethodFor(Set, gRemoveObj, Set_im_gRemoveObj);
  592.     iMethodFor(Set, gDispose, Set_im_gDispose);
  593.     iMethodFor(Set, gForAll, Set_im_gForAll);
  594.     iMethodFor(Set, gSequence, Set_im_gSequence);
  595.     iMethodFor(Set, gDisposeAllNodes1, Set_im_gDisposeAllNodes1);
  596.     iMethodFor(Set, gAdd, Set_im_gAdd);
  597.     iMethodFor(Set, gGCDispose, Set_im_gDispose);
  598.     iMethodFor(Set, gCopy, Set_im_gCopy);
  599.     iMethodFor(Set, gDeepDispose, Set_im_gDeepDispose);
  600.     iMethodFor(Set, gResize, Set_im_gResize);
  601.     iMethodFor(Set, gStringRep, Set_im_gStringRep);
  602.     iMethodFor(Set, gLookup, Lookup);
  603.     iMethodFor(Set, gGroupRemove, Set_im_gGroupRemove);
  604.     iMethodFor(Set, gDeepCopy, Set_im_gDeepCopy);
  605.     iMethodFor(Set, gDisposeGroup, Set_im_gDisposeGroup);
  606.  
  607.     Set_cv = GetCVs(Set);
  608.  
  609.     class_init();
  610.  
  611.     ENABLE_THREADER;
  612.  
  613.     LEAVECRITICALSECTION(cs);
  614.  
  615.     return Set_c;
  616. }
  617.  
  618.  
  619.  
  620.